// ai 不要修改这个文件, 这个文件是参考代码
/*
 * @Author: AI Assistant
 * @Date: 2024-05-07 15:30:00
 * @Last Modified by: AI Assistant
 * @Last Modified time: 2024-05-07 15:30:00
 */

// 后台管理系统页面模板Store文件

// 每个页面都要对应配套一个api文件，无论是否用到
// 由于是模板，这里使用模拟的api导入路径
import pageTemplateApi from '@/api/pageTemplateApi';

// 数据类型必须都要写到@/types/type这个公共文件中
import { PageTemplateStoreData } from '@/types/type';

// 使用mobx进行状态管理
import { makeAutoObservable } from 'mobx';

/**
 * 后台管理系统页面模板的状态管理类
 * 遵循项目统一的开发规范：
 * 1. 类名与文件名保持一致
 * 2. 每个状态值都有对应的设置函数
 * 3. 状态只能通过setter方法修改，不能直接修改
 * 4. 异步操作使用async/await
 * 
 * 额外添加后台管理系统特有的功能：
 * - 分页相关状态和操作
 * - 搜索和筛选相关状态和操作
 * - 批量操作相关状态和操作
 */
class PageTemplateStore {
  constructor() {
    // 初始化mobx观察，使用deep: false提高性能
    makeAutoObservable(this, {}, { deep: false });
  }

  // 基本类型状态值示例
  value1 = 1;
  
  /**
   * 设置value1的值
   * 每个状态值都有一个对应的设置函数，并且这个值只能由这个方法去修改
   */
  setValue1(value1: number) {
    this.value1 = value1;
  }

  // 另一个基本类型状态值示例
  value2 = 2;
  
  /**
   * 设置value2的值
   * 注意：在其他方法中也不能直接修改状态值，只能通过对应的setter方法修改
   * 这是为了方便排查问题和跟踪状态变化
   */
  setValue2(value2: number) {
    this.value2 = value2;
    // 可以在setter中调用其他setter方法
    this.setValue1(value2);
  }

  // 对象或数组类型的状态值示例
  value3: Array<PageTemplateStoreData> = [];
  
  // 后台管理系统特有的状态值
  
  // 加载状态
  loading = false;
  
  /**
   * 设置加载状态
   */
  setLoading(loading: boolean) {
    this.loading = loading;
  }
  
  // 搜索关键词
  searchKeyword = '';
  
  /**
   * 设置搜索关键词
   */
  setSearchKeyword(keyword: string) {
    this.searchKeyword = keyword;
  }
  
  // 当前页码
  currentPage = 1;
  
  /**
   * 设置当前页码
   */
  setCurrentPage(page: number) {
    this.currentPage = page;
  }
  
  // 每页显示数量
  pageSize = 10;
  
  /**
   * 设置每页显示数量
   */
  setPageSize(size: number) {
    this.pageSize = size;
    // 切换每页显示数量时，重置到第一页
    this.setCurrentPage(1);
  }
  
  // 总数据量
  totalCount = 0;
  
  /**
   * 设置总数据量
   */
  setTotalCount(count: number) {
    this.totalCount = count;
  }
  
  // 选中的项ID列表（用于批量操作）
  selectedItems: number[] = [];
  
  /**
   * 设置选中的项
   */
  setSelectedItems(items: number[]) {
    this.selectedItems = items;
  }
  
  /**
   * 添加选中项
   */
  addSelectedItem(id: number) {
    if (!this.selectedItems.includes(id)) {
      this.selectedItems.push(id);
    }
  }
  
  /**
   * 移除选中项
   */
  removeSelectedItem(id: number) {
    this.selectedItems = this.selectedItems.filter(itemId => itemId !== id);
  }
  
  /**
   * 清空选中项
   */
  clearSelectedItems() {
    this.selectedItems = [];
  }
  
  /**
   * 从服务器获取数据的示例方法
   * 模拟API调用，实际项目中会替换为真实的API请求
   * @param isSearch 是否为搜索操作
   */
  async getValue3(isSearch = false) {
    try {
      this.setLoading(true);
      
      // 调用API获取数据
      // const res = await pageTemplateApi.get_data({
      //   page: this.currentPage,
      //   pageSize: this.pageSize,
      //   keyword: this.searchKeyword
      // });
      // if (res.code === 200) {
      //   this.value3 = res.data.list;
      //   this.setTotalCount(res.data.total);
      // }
      
      // 模拟API调用成功的响应
      // 实际项目中应替换为真实的API调用
      await new Promise(resolve => setTimeout(resolve, 500)); // 模拟网络延迟
      
      // 模拟数据
      let mockData: PageTemplateStoreData[] = [];
      const baseId = (this.currentPage - 1) * this.pageSize;
      const itemCount = Math.min(this.pageSize, 20); // 模拟最多20条数据
      
      for (let i = 0; i < itemCount; i++) {
        const id = baseId + i + 1;
        // 如果有搜索关键词，只返回包含关键词的数据
        if (this.searchKeyword && !`模板数据项${id}`.includes(this.searchKeyword)) {
          continue;
        }
        mockData.push({
          id,
          name: `模板数据项${id}`
        });
      }
      
      this.value3 = mockData;
      this.setTotalCount(20); // 模拟总数据量为20条
      
      // 如果是搜索操作，清空选中项
      if (isSearch) {
        this.clearSelectedItems();
      }
      
      return true;
    } catch (error) {
      console.error('获取数据失败:', error);
      return false;
    } finally {
      this.setLoading(false);
    }
  }

  /**
   * 执行搜索操作
   */
  async doSearch() {
    this.setCurrentPage(1); // 搜索时重置到第一页
    return await this.getValue3(true);
  }

  /**
   * 执行重置操作
   */
  async doReset() {
    this.setSearchKeyword('');
    this.setCurrentPage(1);
    this.clearSelectedItems();
    return await this.getValue3();
  }

  /**
   * 切换到上一页
   */
  async prevPage() {
    if (this.currentPage > 1) {
      this.setCurrentPage(this.currentPage - 1);
      this.clearSelectedItems(); // 切换页码时清空选中项
      return await this.getValue3();
    }
    return false;
  }

  /**
   * 切换到下一页
   */
  async nextPage() {
    const totalPages = Math.ceil(this.totalCount / this.pageSize);
    if (this.currentPage < totalPages) {
      this.setCurrentPage(this.currentPage + 1);
      this.clearSelectedItems(); // 切换页码时清空选中项
      return await this.getValue3();
    }
    return false;
  }

  /**
   * 添加新数据项
   */
  async addDataItem(item: PageTemplateStoreData) {
    try {
      this.setLoading(true);
      
      // 实际项目中这里会调用API添加数据
      // const res = await pageTemplateApi.add_data(item);
      // if (res.code === 200) {
      //   // 添加成功后刷新数据
      //   await this.getValue3();
      // }
      
      // 模拟添加数据
      await new Promise(resolve => setTimeout(resolve, 300));
      this.value3.push({ ...item });
      this.setTotalCount(this.totalCount + 1);
      
      return true;
    } catch (error) {
      console.error('添加数据失败:', error);
      return false;
    } finally {
      this.setLoading(false);
    }
  }

  /**
   * 更新指定ID的数据项
   */
  async updateDataItem(id: number, updatedData: Partial<PageTemplateStoreData>) {
    try {
      this.setLoading(true);
      
      // 实际项目中这里会调用API更新数据
      // const res = await pageTemplateApi.update_data(id, updatedData);
      // if (res.code === 200) {
      //   // 更新成功后刷新数据
      //   await this.getValue3();
      // }
      
      // 模拟更新数据
      await new Promise(resolve => setTimeout(resolve, 300));
      const index = this.value3.findIndex(item => item.id === id);
      if (index !== -1) {
        this.value3[index] = { ...this.value3[index], ...updatedData };
      }
      
      return true;
    } catch (error) {
      console.error('更新数据失败:', error);
      return false;
    } finally {
      this.setLoading(false);
    }
  }

  /**
   * 删除指定ID的数据项
   */
  async deleteDataItem(id: number) {
    try {
      this.setLoading(true);
      
      // 实际项目中这里会调用API删除数据
      // const res = await pageTemplateApi.delete_data(id);
      // if (res.code === 200) {
      //   // 删除成功后刷新数据
      //   await this.getValue3();
      // }
      
      // 模拟删除数据
      await new Promise(resolve => setTimeout(resolve, 300));
      this.value3 = this.value3.filter(item => item.id !== id);
      this.setTotalCount(Math.max(0, this.totalCount - 1));
      
      // 从选中项中移除
      this.removeSelectedItem(id);
      
      return true;
    } catch (error) {
      console.error('删除数据失败:', error);
      return false;
    } finally {
      this.setLoading(false);
    }
  }

  /**
   * 批量删除数据项
   */
  async batchDeleteDataItems(ids: number[]) {
    try {
      this.setLoading(true);
      
      // 实际项目中这里会调用API批量删除数据
      // const res = await pageTemplateApi.batch_delete_data(ids);
      // if (res.code === 200) {
      //   // 删除成功后刷新数据
      //   await this.getValue3();
      // }
      
      // 模拟批量删除数据
      await new Promise(resolve => setTimeout(resolve, 500));
      this.value3 = this.value3.filter(item => !ids.includes(item.id));
      this.setTotalCount(Math.max(0, this.totalCount - ids.length));
      
      // 清空选中项
      this.clearSelectedItems();
      
      return true;
    } catch (error) {
      console.error('批量删除数据失败:', error);
      return false;
    } finally {
      this.setLoading(false);
    }
  }

  /**
   * 清空所有数据
   */
  clearData() {
    this.value3 = [];
    this.setValue1(1);
    this.setValue2(2);
    this.setCurrentPage(1);
    this.setSearchKeyword('');
    this.clearSelectedItems();
    this.setTotalCount(0);
  }
}

// 创建并导出store实例
// 实例名称与文件名保持一致（去掉后缀）
const pageTemplateStore = new PageTemplateStore();

export default pageTemplateStore;